Shaped Hierarchical Architectural Design

The architectural design of systems deals with the high level structuring of configurations. Checking that a system belongs to an architectural style (or shape) implies that the architecture is an instance of a structurally defined class. On the other side, hierarchies allow modeling at different levels of detail: subsystems may be represented as single components to abstract structure and behavior. This talk presents an approach for representing hierarchical software architecture shapes using types [1]. Typing proofs define a general framework based on inference rules where shape rules and graphs representing system configurations are represented as type judgements [2]. Therefore, if there is a typing proof for a judgment, then the system is correctly shaped (i.e. typed), where the axioms of the type system are the shaping rules of a style. An aspect strongly related to shape is SA reconfiguration. Reconfiguration has to respect shape, i.e. type. But for design, just observing the actual configuration may not be enough. Instead, observing the steps taken to obtain the final system may provide important information about the process of construction. We claim that proof terms (i.e., terms of rule names encoding typing proofs) provide more information than just graphs about the process of constructing systems and allow to specify reconfigurations as proof term rewritings. Then, reconfiguration consistency is obtained as subject reduction: as long as cutting and pasting typing proofs still yields typing proofs, subject reduction is guaranteed. Also, our approach allows the integration of shapes and hierarchies. Hierarchical composition allows to describe systems at different levels of detail. Hierarchical structures are present in many aspects related with system configuration, and in areas like process calculi (Ambient Calculus), concurrent system modeling (Bigraphs), UML (e.g. state charts with decomposition and refinement). In our case, hierarchical structure is captured via hierarchy constructors which are similar to basic constants, i.e. only type and name is specified. Then for each hierarchical constructor a standard ”symbolic” body is defined as a type judgment. Hierarchical graphs can be derived in the resulting type system.